home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / SourceCode / GameKit / gamekit-1 / Animator.m < prev    next >
Text File  |  1995-06-12  |  5KB  |  229 lines
  1. //  Animator.m
  2. //  Object for general timing, animation, and dynamics.
  3. //  Author: R. E. Crandall, Educational Technology Center
  4. //  10-Apr-88
  5. //  Revised by Bluce Blumberg for 0.8, 29-Sep-88
  6. //  Revised for 1.0 by Ali Ozer, 13-Jun-89
  7. //  Revised for 2.0 by Jayson Adams, 14-Oct-90
  8. //
  9. // You may freely copy, distribute and reuse the code in this example.
  10. // NeXT disclaims any warranty of any kind, expressed or implied, as to its
  11. // fitness for any particular use.
  12.  
  13. /*
  14.  *  An 'Animator' controls the timing for your action method of choice.
  15.  *  The object may function as a general timer object; i.e.
  16.  *  graphics are neither expected nor required by the class.
  17.  *  When you create an Animator with +newChronon, you specify
  18.  *  the time interval between calls, the adaptation time constant (see below),
  19.  *  the target to which the method belongs, the action name, whether to 
  20.  *  automatically start up the timing upon creation, and an event mask (if you     
  21.  *  plan to break conditionally out of loops within the action method).
  22.  *
  23.  *  The Animator has adaptive means for adjusting to harsh operating
  24.  *  environments.  An adaptation constant d > 0. will invoke dynamical 
  25.  *  correction of entry times, on-the-fly, so that the desired chronon
  26.  *  will be realized in a real-time sense.
  27.  *
  28.  *  Functionality and applications are discussed in Report ETC-0008.
  29.  */
  30.  
  31. #import <gamekit/Animator.h>
  32.  
  33. #import <appkit/appkit.h>
  34. #import <sys/time.h>
  35. #import <objc/objc-runtime.h>
  36.  
  37.  
  38. @implementation Animator
  39.  
  40. void timerFunction(teNum, now, self)
  41. DPSTimedEntry teNum;
  42. double now;
  43. Animator *self;
  44. {
  45.     gettimeofday(&self->entrytime, NULL);
  46.     if (self->howOften > 0.0) {
  47.     [self adapt];
  48.     }
  49.     
  50.     [self->target perform:self->action with:self];
  51. }
  52.  
  53. - initChronon:(double)dt    /* The time increment desired. */
  54.   adaptation:(double)howoft    /* Adaptive time constant (0.deactivates).*/
  55.   target:(id)targ        /* Target to whom proc belongs. */
  56.   action:(SEL)act        /* The action. */
  57.   autoStart:(int)start        /* Automatic start of timed entry? */
  58.   eventMask:(int)eMask        /* Mask for optional check in "shouldBreak". */
  59. {
  60.     [super init];
  61.     ticking = NO;
  62.     desireddt = dt;
  63.     [self setIncrement:dt];
  64.     [self setAdaptation:howoft];
  65.     [self setTarget:targ];
  66.     [self setAction:act];
  67.     
  68.     if (start) {
  69.     [self startEntry];
  70.     }
  71.     
  72.     mask = eMask;
  73.     [self resetRealTime];
  74.     
  75.     return self;
  76. }
  77.  
  78. - resetRealTime
  79. /* After this call, getDoubleRealTime is the real time that ensues. */
  80. { 
  81.     struct timeval    realtime;
  82.     
  83.     gettimeofday(&realtime, NULL);
  84.     synctime = realtime.tv_sec + realtime.tv_usec / 1000000.0;
  85.     passcounter = 0;
  86.     t0 = 0.0;
  87.     
  88.     return self;
  89. }
  90.  
  91. - (double)getSyncTime
  92. {
  93.     return synctime;
  94. }
  95.  
  96. - (double)getDoubleEntryTime
  97. /* Returns real time since "resetrealTime". */
  98. {
  99.     return (- synctime + entrytime.tv_sec + entrytime.tv_usec / 1000000.0);
  100. }
  101.  
  102. - (double)getDoubleRealTime
  103. /* Returns real time since "resetrealTime". */
  104. {
  105.     struct timeval    realtime;
  106.     struct timezone    tzone;
  107.     
  108.     gettimeofday(&realtime, &tzone);
  109.     return (- synctime + realtime.tv_sec + realtime.tv_usec / 1000000.0);
  110. }
  111.  
  112. - (double)getDouble
  113. {
  114.     return [self getDoubleRealTime];
  115. }
  116.  
  117. - adapt
  118. /* Adaptive time-step algorithm. */
  119. {
  120.     double t;
  121.     
  122.     if (!ticking) {
  123.     return self;
  124.     }
  125.     
  126.     ++passcounter;
  127.     t = [self getDoubleEntryTime];
  128.     
  129.     if (t - t0 >= howOften) {      
  130.     adapteddt *= desireddt * passcounter / (t - t0);
  131.     [self setIncrement:adapteddt];
  132.     [self startEntry];
  133.     passcounter = 0;
  134.     t0 = t;
  135.     }
  136.     return self;
  137. }
  138.   
  139. - setBreakMask:(int)eventMask
  140. {
  141.     mask = eventMask;
  142.     return self;
  143. }
  144.  
  145. - (int)getBreakMask
  146. {
  147.     return mask;
  148. }
  149.  
  150. - (int)isTicking
  151. {
  152.     return ticking;
  153. }
  154.    
  155. - (int)shouldBreak
  156. /* Call this to see if you want to exit a loop in your action method. */
  157. {
  158.     NXEvent    *e, event;
  159.     
  160.     e = [NXApp peekNextEvent:mask
  161.                into:&event
  162.            waitFor:0.0
  163.            threshold:NX_MODALRESPTHRESHOLD + 1];
  164.            
  165.     return (e ? 1: 0);
  166. }
  167.  
  168. - setIncrement:(double)dt
  169. {
  170.     adapteddt = dt;
  171.     interval = dt;
  172.   
  173.     return self;
  174. }
  175.  
  176. - (double)getIncrement
  177. {
  178.     return adapteddt;
  179. }
  180.  
  181. - setAdaptation:(double)oft
  182. {
  183.     howOften = oft;
  184.     return self;
  185. }
  186.  
  187. - setTarget:(id)targ
  188. {
  189.     target = targ;
  190.     return self;
  191. }
  192.  
  193. - setAction:(SEL)aSelector
  194. {
  195.     action = aSelector;
  196.     return self;
  197. }
  198.  
  199. - startEntry
  200. { 
  201.     [self stopEntry];
  202.     teNum = DPSAddTimedEntry(interval, &timerFunction, self,
  203.                      NX_MODALRESPTHRESHOLD+1);
  204.     ticking = YES;
  205.     
  206.     return self;
  207. }
  208.  
  209. - stopEntry
  210. {
  211.     if (ticking) {
  212.     DPSRemoveTimedEntry(teNum);
  213.     }
  214.     ticking = NO;
  215.     
  216.     return self;
  217. }
  218.  
  219. - free
  220. {
  221.     if (ticking) {
  222.     DPSRemoveTimedEntry(teNum);
  223.     }
  224.     
  225.     return [super free];
  226. }
  227.  
  228. @end    
  229.